import { get, post, put, del } from "@/utils/api";
import request from "@/utils/request";
import { API_ENDPOINTS, API_BASE_URL } from "@/config/api";

/**
 * 获取对话列表
 * @param {number} page - 页码，默认为1
 * @param {number} pageSize - 每页数量，默认为10
 * @returns {Promise} 返回对话列表数据（分页结构）
 */
export const getConversationList = (page = 1, pageSize = 10) => {
  return get(API_ENDPOINTS.CONVERSATIONS.LIST, {
    page,
    page_size: pageSize,
  });
};

/**
 * 创建新对话
 * @param {object} payload - 创建对话的请求体
 * @returns {Promise}
 */
export const createConversation = (payload = {}) => {
  return post(API_ENDPOINTS.CONVERSATIONS.CREATE, payload);
};

/**
 * 更新对话标题
 * @param {number} conversationId - 对话ID
 * @param {string} title - 新标题
 * @returns {Promise}
 */
export const updateConversationTitle = (conversationId, title) => {
  return put(API_ENDPOINTS.CONVERSATIONS.UPDATE(conversationId), { title });
};

/**
 * 删除对话
 * @param {number} conversationId - 对话ID
 * @returns {Promise}
 */
export const deleteConversationById = (conversationId) => {
  return del(API_ENDPOINTS.CONVERSATIONS.DELETE(conversationId));
};

/**
 * 上传文件到对话
 * @param {number} conversationId - 对话ID
 * @param {File} file - 要上传的文件
 * @returns {Promise}
 */
export const uploadChatFile = (conversationId, file) => {
  const formData = new FormData();
  formData.append("file", file);

  return request({
    method: "post",
    url: API_ENDPOINTS.CHAT.UPLOAD(conversationId),
    data: formData,
    headers: {
      "Content-Type": "multipart/form-data",
    },
    timeout: 20000, // 文件上传超时时间设置为20秒
  });
};

/**
 * 发送消息（流式返回）
 * @param {number|string} conversationId - 对话ID（可能是临时ID或后端ID）
 * @param {string} content - 消息内容
 * @param {Array<number>} fileIds - 文件ID数组
 * @param {boolean} loadKnowledge - 是否加载知识库，默认为true
 * @param {Function} onChunk - 接收数据块的回调函数
 * @param {Function} onComplete - 完成回调函数
 * @param {Function} onError - 错误回调函数
 * @returns {Promise<{conversationId: string|number|null}>} 返回包含对话ID的对象
 */
export const sendChatMessage = async (
  conversationId,
  content,
  fileIds = [],
  loadKnowledge = true,
  onChunk,
  onComplete,
  onError
) => {
  try {
    // ========== 测试模式：模拟服务器繁忙超时 ==========
    // 如果消息内容包含 "test-timeout" 或 "测试超时"，则模拟超时场景
    const isTestTimeout = content && (
      content.includes("test-timeout") || 
      content.includes("测试超时") ||
      content.includes("模拟超时")
    );
    
    if (isTestTimeout) {
      console.log("🧪 测试模式：模拟服务器繁忙超时场景");
      // 模拟一个延迟，然后触发超时错误
      await new Promise((resolve) => setTimeout(resolve, 2000)); // 等待2秒
      if (onError) {
        onError(new Error("服务器繁忙，请您稍后重试！"));
      }
      return { conversationId: null };
    }
    // ========== 测试模式结束 ==========
    
    // 获取认证信息
    const authStore = localStorage.getItem("auth");
    let headers = {
      "Content-Type": "application/json",
    };

    if (authStore) {
      try {
        const auth = JSON.parse(authStore);
        if (auth.isAuthenticated && auth.user && auth.user.access_token) {
          const tokenType = auth.user.token_type || "bearer";
          headers.Authorization = `${tokenType} ${auth.user.access_token}`;
        }
      } catch (e) {
        console.error("解析认证信息失败", e);
      }
    }

    // 使用配置文件中的API_BASE_URL
    const baseURL = API_BASE_URL;
    const url = `${baseURL}${API_ENDPOINTS.CHAT.SEND(conversationId)}`;

    // 使用fetch进行流式请求
    const response = await fetch(url, {
      method: "POST",
      headers: headers,
      body: JSON.stringify({
        content: content,
        file_ids: fileIds,
        loadKnowledge: loadKnowledge,
      }),
    });

    if (!response.ok) {
      // 尝试解析错误响应
      try {
        const contentType = response.headers.get("content-type");
        if (contentType && contentType.includes("application/json")) {
          const errorData = await response.json();
          if (errorData.detail && Array.isArray(errorData.detail)) {
            // 这是验证错误格式，提取错误信息
            const errorMessages = errorData.detail
              .map((item) => {
                const location = item.loc ? item.loc.join(".") : "";
                return location
                  ? `${location}: ${item.msg || item.type}`
                  : item.msg || item.type;
              })
              .join("; ");
            throw new Error(errorMessages || "请求参数验证失败");
          }
          throw new Error(
            errorData.message ||
              errorData.msg ||
              `HTTP error! status: ${response.status}`
          );
        }
        throw new Error(`HTTP error! status: ${response.status}`);
      } catch (parseError) {
        // 如果解析失败，使用默认错误信息
        if (parseError.message) {
          throw parseError;
        }
        throw new Error(`HTTP error! status: ${response.status}`);
      }
    }

    // 读取流式响应
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = "";
    let hasError = false;
    let returnedConversationId = null; // 用于存储返回的对话ID

    // 超时处理：如果1分钟内没有收到任何数据，认为超时
    const TIMEOUT = 60000; // 60秒（1分钟）
    let lastDataTime = Date.now();
    let timeoutTimer = null;

    // 设置超时检测
    const resetTimeout = () => {
      if (timeoutTimer) {
        clearTimeout(timeoutTimer);
      }
      timeoutTimer = setTimeout(() => {
        const timeSinceLastData = Date.now() - lastDataTime;
        if (timeSinceLastData >= TIMEOUT) {
          hasError = true;
          reader.cancel();
          if (onError) {
            onError(new Error("服务器繁忙，请您稍后重试！"));
          }
        }
      }, TIMEOUT);
    };

    // 启动超时检测
    resetTimeout();

    while (true) {
      const { done, value } = await reader.read();

      if (done) {
        break;
      }

      // 如果已经遇到错误，停止读取
      if (hasError) {
        break;
      }

      // 重置超时计时器（收到数据）
      lastDataTime = Date.now();
      resetTimeout();

      // 解码数据块（立即处理，不等待）
      const chunk = decoder.decode(value, { stream: true });
      buffer += chunk;

      // 处理可能的多行数据（立即处理每一行）
      const lines = buffer.split("\n");
      buffer = lines.pop() || ""; // 保留最后一个不完整的行

      for (const line of lines) {
        if (line.trim() && !hasError) {
          try {
            // 处理SSE格式（data: 前缀）
            let data = line.trim();
            if (data.startsWith("data: ")) {
              data = data.substring(6).trim();
            }

            // 跳过SSE格式的其他行（如event:, id:等）
            if (
              data.startsWith("event:") ||
              data.startsWith("id:") ||
              data === ""
            ) {
              continue;
            }

            if (data) {
              // 尝试解析JSON
              try {
                const parsed = JSON.parse(data);

                // 检查是否是错误格式（包含detail字段）
                if (parsed.detail && Array.isArray(parsed.detail)) {
                  // 这是验证错误格式，提取错误信息
                  const errorMessages = parsed.detail
                    .map((item) => {
                      const location = item.loc ? item.loc.join(".") : "";
                      return location
                        ? `${location}: ${item.msg || item.type}`
                        : item.msg || item.type;
                    })
                    .join("; ");

                  hasError = true;
                  if (onError) {
                    onError(new Error(errorMessages || "请求参数验证失败"));
                  }
                  // 取消读取
                  reader.cancel();
                  return; // 停止处理
                }

                // 检查是否包含对话ID
                if (parsed.conversation_id !== undefined) {
                  returnedConversationId = parsed.conversation_id;
                } else if (parsed.conversationId !== undefined) {
                  returnedConversationId = parsed.conversationId;
                } else if (parsed.cid !== undefined) {
                  returnedConversationId = parsed.cid;
                }

                if (onChunk && !hasError) {
                  // 立即调用回调，实现实时显示
                  onChunk(parsed);
                }
              } catch (jsonError) {
                // 如果不是JSON，直接作为文本内容处理
                if (onChunk && !hasError) {
                  // 立即调用回调，实现实时显示
                  onChunk({ content: data });
                }
              }
            }
          } catch (e) {
            // 如果处理失败，尝试直接作为文本
            if (onChunk && !hasError && line.trim()) {
              onChunk({ content: line.trim() });
            }
          }
        }
      }
    }

    // 处理剩余的buffer（如果没有错误）
    if (buffer.trim() && !hasError) {
      try {
        let data = buffer.trim();
        if (data.startsWith("data: ")) {
          data = data.substring(6).trim();
        }

        // 跳过SSE格式的其他行
        if (data && !data.startsWith("event:") && !data.startsWith("id:")) {
          try {
            const parsed = JSON.parse(data);

            // 检查是否是错误格式（包含detail字段）
            if (parsed.detail && Array.isArray(parsed.detail)) {
              // 这是验证错误格式，提取错误信息
              const errorMessages = parsed.detail
                .map((item) => {
                  const location = item.loc ? item.loc.join(".") : "";
                  return location
                    ? `${location}: ${item.msg || item.type}`
                    : item.msg || item.type;
                })
                .join("; ");

              if (onError) {
                onError(new Error(errorMessages || "请求参数验证失败"));
              }
              return; // 停止处理
            }

            if (onChunk) {
              onChunk(parsed);
            }
          } catch (jsonError) {
            // 如果不是JSON，直接作为文本内容处理
            if (onChunk) {
              onChunk({ content: data });
            }
          }
        }
      } catch (e) {
        if (onChunk && buffer.trim()) {
          onChunk({ content: buffer.trim() });
        }
      }
    }

    // 清除超时计时器
    if (timeoutTimer) {
      clearTimeout(timeoutTimer);
      timeoutTimer = null;
    }

    // 只有在没有错误的情况下才调用完成回调
    if (!hasError && onComplete) {
      onComplete(returnedConversationId);
    }
    
    // 返回对话ID（如果有的话）
    return { conversationId: returnedConversationId };
  } catch (error) {
    console.error("发送消息失败", error);

    // 清除超时计时器
    if (timeoutTimer) {
      clearTimeout(timeoutTimer);
      timeoutTimer = null;
    }

    // 处理网络错误或超时错误
    let errorMessage = error.message || "发送消息失败，请重试";
    if (
      error.name === "AbortError" ||
      error.message.includes("timeout") ||
      error.message.includes("超时")
    ) {
      errorMessage = "服务器繁忙，请您稍后重试！";
    } else if (
      error.message.includes("network") ||
      error.message.includes("网络")
    ) {
      errorMessage = "网络连接异常，请检查网络后重试";
    }

    if (onError) {
      onError(new Error(errorMessage));
    } else {
      throw new Error(errorMessage);
    }
  }
};
